home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / java / lang / ThreadGroup.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  5.9 KB  |  632 lines
  1. package java.lang;
  2.  
  3. import java.io.PrintStream;
  4.  
  5. public class ThreadGroup {
  6.    ThreadGroup parent;
  7.    String name;
  8.    int maxPriority;
  9.    boolean destroyed;
  10.    boolean daemon;
  11.    boolean vmAllowSuspension;
  12.    int nthreads;
  13.    Thread[] threads;
  14.    int ngroups;
  15.    ThreadGroup[] groups;
  16.  
  17.    private ThreadGroup() {
  18.       this.name = "system";
  19.       this.maxPriority = 10;
  20.    }
  21.  
  22.    public ThreadGroup(String var1) {
  23.       this(Thread.currentThread().getThreadGroup(), var1);
  24.    }
  25.  
  26.    public ThreadGroup(ThreadGroup var1, String var2) {
  27.       if (var1 == null) {
  28.          throw new NullPointerException();
  29.       } else {
  30.          var1.checkAccess();
  31.          this.name = var2;
  32.          this.maxPriority = var1.maxPriority;
  33.          this.daemon = var1.daemon;
  34.          this.vmAllowSuspension = var1.vmAllowSuspension;
  35.          this.parent = var1;
  36.          var1.add(this);
  37.       }
  38.    }
  39.  
  40.    public final String getName() {
  41.       return this.name;
  42.    }
  43.  
  44.    public final ThreadGroup getParent() {
  45.       return this.parent;
  46.    }
  47.  
  48.    public final int getMaxPriority() {
  49.       return this.maxPriority;
  50.    }
  51.  
  52.    public final boolean isDaemon() {
  53.       return this.daemon;
  54.    }
  55.  
  56.    public synchronized boolean isDestroyed() {
  57.       return this.destroyed;
  58.    }
  59.  
  60.    public final void setDaemon(boolean var1) {
  61.       System.getSecurityManager().checkAccess(this);
  62.       this.daemon = var1;
  63.    }
  64.  
  65.    public final void setMaxPriority(int var1) {
  66.       synchronized(this){}
  67.  
  68.       int var2;
  69.       ThreadGroup[] var3;
  70.       try {
  71.          System.getSecurityManager().checkAccess(this);
  72.          if (var1 < 1) {
  73.             this.maxPriority = 1;
  74.          } else if (var1 < this.maxPriority) {
  75.             this.maxPriority = var1;
  76.          }
  77.  
  78.          var2 = this.ngroups;
  79.          if (this.groups != null) {
  80.             var3 = new ThreadGroup[var2];
  81.             System.arraycopy(this.groups, 0, var3, 0, var2);
  82.          } else {
  83.             var3 = null;
  84.          }
  85.       } catch (Throwable var6) {
  86.          throw var6;
  87.       }
  88.  
  89.       for(int var4 = 0; var4 < var2; ++var4) {
  90.          var3[var4].setMaxPriority(var1);
  91.       }
  92.  
  93.    }
  94.  
  95.    public final boolean parentOf(ThreadGroup var1) {
  96.       while(var1 != null) {
  97.          if (var1 == this) {
  98.             return true;
  99.          }
  100.  
  101.          var1 = var1.parent;
  102.       }
  103.  
  104.       return false;
  105.    }
  106.  
  107.    public final void checkAccess() {
  108.       System.getSecurityManager().checkAccess(this);
  109.    }
  110.  
  111.    public synchronized int activeCount() {
  112.       if (this.destroyed) {
  113.          return 0;
  114.       } else {
  115.          ThreadGroup var1 = this.enumeratableThreadGroup();
  116.          return var1 == null ? 0 : var1.activeCount0();
  117.       }
  118.    }
  119.  
  120.    private int activeCount0() {
  121.       synchronized(this){}
  122.  
  123.       int var1;
  124.       int var2;
  125.       ThreadGroup[] var3;
  126.       try {
  127.          if (this.destroyed) {
  128.             byte var9 = 0;
  129.             return var9;
  130.          }
  131.  
  132.          var1 = this.nthreads;
  133.          var2 = this.ngroups;
  134.          if (this.groups != null) {
  135.             var3 = new ThreadGroup[var2];
  136.             System.arraycopy(this.groups, 0, var3, 0, var2);
  137.          } else {
  138.             var3 = null;
  139.          }
  140.       } catch (Throwable var8) {
  141.          throw var8;
  142.       }
  143.  
  144.       for(int var4 = 0; var4 < var2; ++var4) {
  145.          var1 += var3[var4].activeCount0();
  146.       }
  147.  
  148.       return var1;
  149.    }
  150.  
  151.    public int enumerate(Thread[] var1) {
  152.       return this.enumerate(var1, true);
  153.    }
  154.  
  155.    public int enumerate(Thread[] var1, boolean var2) {
  156.       ThreadGroup var3 = this.enumeratableThreadGroup();
  157.       return var3 != null && (var2 || this == var3) ? var3.enumerate((Thread[])var1, 0, var2) : 0;
  158.    }
  159.  
  160.    private int enumerate(Thread[] var1, int var2, boolean var3) {
  161.       int var4 = 0;
  162.       ThreadGroup[] var5 = null;
  163.       synchronized(this){}
  164.  
  165.       try {
  166.          if (this.destroyed) {
  167.             byte var12 = 0;
  168.             return var12;
  169.          }
  170.  
  171.          int var9 = this.nthreads;
  172.          if (var9 > var1.length - var2) {
  173.             var9 = var1.length - var2;
  174.          }
  175.  
  176.          if (var9 > 0) {
  177.             System.arraycopy(this.threads, 0, var1, var2, var9);
  178.             var2 += var9;
  179.          }
  180.  
  181.          if (var3) {
  182.             var4 = this.ngroups;
  183.             if (this.groups != null) {
  184.                var5 = new ThreadGroup[var4];
  185.                System.arraycopy(this.groups, 0, var5, 0, var4);
  186.             } else {
  187.                var5 = null;
  188.             }
  189.          }
  190.       } catch (Throwable var11) {
  191.          throw var11;
  192.       }
  193.  
  194.       if (var3) {
  195.          for(int var6 = 0; var6 < var4; ++var6) {
  196.             var2 = var5[var6].enumerate(var1, var2, true);
  197.          }
  198.       }
  199.  
  200.       return var2;
  201.    }
  202.  
  203.    public synchronized int activeGroupCount() {
  204.       if (this.destroyed) {
  205.          return 0;
  206.       } else {
  207.          ThreadGroup var1 = this.enumeratableThreadGroup();
  208.          if (var1 == null) {
  209.             return 0;
  210.          } else {
  211.             int var2 = 0;
  212.  
  213.             for(ThreadGroup var3 = var1; var3 != this; var3 = var3.parent) {
  214.                ++var2;
  215.             }
  216.  
  217.             return var2 + var1.activeGroupCount0();
  218.          }
  219.       }
  220.    }
  221.  
  222.    private int activeGroupCount0() {
  223.       synchronized(this){}
  224.  
  225.       int var1;
  226.       ThreadGroup[] var2;
  227.       try {
  228.          if (this.destroyed) {
  229.             byte var8 = 0;
  230.             return var8;
  231.          }
  232.  
  233.          var1 = this.ngroups;
  234.          if (this.groups != null) {
  235.             var2 = new ThreadGroup[var1];
  236.             System.arraycopy(this.groups, 0, var2, 0, var1);
  237.          } else {
  238.             var2 = null;
  239.          }
  240.       } catch (Throwable var7) {
  241.          throw var7;
  242.       }
  243.  
  244.       int var3 = var1;
  245.  
  246.       for(int var4 = 0; var4 < var1; ++var4) {
  247.          var3 += var2[var4].activeGroupCount0();
  248.       }
  249.  
  250.       return var3;
  251.    }
  252.  
  253.    public int enumerate(ThreadGroup[] var1) {
  254.       return this.enumerate(var1, true);
  255.    }
  256.  
  257.    public synchronized int enumerate(ThreadGroup[] var1, boolean var2) {
  258.       ThreadGroup var3 = this.enumeratableThreadGroup();
  259.       if (var3 == null) {
  260.          return 0;
  261.       } else {
  262.          int var4 = 0;
  263.          var4 = this.enumerateChildren(var3, var1, var2);
  264.          return !var2 && var4 > 0 ? var4 : var3.enumerate(var1, var4, var2);
  265.       }
  266.    }
  267.  
  268.    private int enumerateChildren(ThreadGroup var1, ThreadGroup[] var2, boolean var3) {
  269.       if (this == var1) {
  270.          return 0;
  271.       } else {
  272.          ThreadGroup var4 = var1.parent;
  273.          int var5 = this.enumerateChildren(var4, var2, var3);
  274.          if (var5 < var2.length && (var5 == 0 || var3)) {
  275.             var2[var5++] = var1;
  276.          }
  277.  
  278.          return var5;
  279.       }
  280.    }
  281.  
  282.    private int enumerate(ThreadGroup[] var1, int var2, boolean var3) {
  283.       int var4 = 0;
  284.       ThreadGroup[] var5 = null;
  285.       synchronized(this){}
  286.  
  287.       try {
  288.          if (this.destroyed) {
  289.             byte var12 = 0;
  290.             return var12;
  291.          }
  292.  
  293.          int var9 = this.ngroups;
  294.          if (var9 > var1.length - var2) {
  295.             var9 = var1.length - var2;
  296.          }
  297.  
  298.          if (var9 > 0) {
  299.             System.arraycopy(this.groups, 0, var1, var2, var9);
  300.             var2 += var9;
  301.          }
  302.  
  303.          if (var3) {
  304.             var4 = this.ngroups;
  305.             if (this.groups != null) {
  306.                var5 = new ThreadGroup[var4];
  307.                System.arraycopy(this.groups, 0, var5, 0, var4);
  308.             } else {
  309.                var5 = null;
  310.             }
  311.          }
  312.       } catch (Throwable var11) {
  313.          throw var11;
  314.       }
  315.  
  316.       if (var3) {
  317.          for(int var6 = 0; var6 < var4; ++var6) {
  318.             var2 = var5[var6].enumerate(var1, var2, true);
  319.          }
  320.       }
  321.  
  322.       return var2;
  323.    }
  324.  
  325.    public final void stop() {
  326.       synchronized(this){}
  327.  
  328.       int var1;
  329.       ThreadGroup[] var2;
  330.       try {
  331.          System.getSecurityManager().checkAccess(this);
  332.  
  333.          for(int var5 = 0; var5 < this.nthreads; ++var5) {
  334.             this.threads[var5].stop();
  335.          }
  336.  
  337.          var1 = this.ngroups;
  338.          if (this.groups != null) {
  339.             var2 = new ThreadGroup[var1];
  340.             System.arraycopy(this.groups, 0, var2, 0, var1);
  341.          } else {
  342.             var2 = null;
  343.          }
  344.       } catch (Throwable var7) {
  345.          throw var7;
  346.       }
  347.  
  348.       for(int var3 = 0; var3 < var1; ++var3) {
  349.          var2[var3].stop();
  350.       }
  351.  
  352.    }
  353.  
  354.    public final void suspend() {
  355.       synchronized(this){}
  356.  
  357.       int var1;
  358.       ThreadGroup[] var2;
  359.       try {
  360.          System.getSecurityManager().checkAccess(this);
  361.  
  362.          for(int var5 = 0; var5 < this.nthreads; ++var5) {
  363.             this.threads[var5].suspend();
  364.          }
  365.  
  366.          var1 = this.ngroups;
  367.          if (this.groups != null) {
  368.             var2 = new ThreadGroup[var1];
  369.             System.arraycopy(this.groups, 0, var2, 0, var1);
  370.          } else {
  371.             var2 = null;
  372.          }
  373.       } catch (Throwable var7) {
  374.          throw var7;
  375.       }
  376.  
  377.       for(int var3 = 0; var3 < var1; ++var3) {
  378.          var2[var3].suspend();
  379.       }
  380.  
  381.    }
  382.  
  383.    public final void resume() {
  384.       synchronized(this){}
  385.  
  386.       int var1;
  387.       ThreadGroup[] var2;
  388.       try {
  389.          System.getSecurityManager().checkAccess(this);
  390.  
  391.          for(int var5 = 0; var5 < this.nthreads; ++var5) {
  392.             this.threads[var5].resume();
  393.          }
  394.  
  395.          var1 = this.ngroups;
  396.          if (this.groups != null) {
  397.             var2 = new ThreadGroup[var1];
  398.             System.arraycopy(this.groups, 0, var2, 0, var1);
  399.          } else {
  400.             var2 = null;
  401.          }
  402.       } catch (Throwable var7) {
  403.          throw var7;
  404.       }
  405.  
  406.       for(int var3 = 0; var3 < var1; ++var3) {
  407.          var2[var3].resume();
  408.       }
  409.  
  410.    }
  411.  
  412.    public final void destroy() {
  413.       synchronized(this){}
  414.  
  415.       int var1;
  416.       ThreadGroup[] var2;
  417.       try {
  418.          System.getSecurityManager().checkAccess(this);
  419.          if (this.destroyed || this.nthreads > 0) {
  420.             throw new IllegalThreadStateException();
  421.          }
  422.  
  423.          var1 = this.ngroups;
  424.          if (this.groups != null) {
  425.             var2 = new ThreadGroup[var1];
  426.             System.arraycopy(this.groups, 0, var2, 0, var1);
  427.          } else {
  428.             var2 = null;
  429.          }
  430.  
  431.          if (this.parent != null) {
  432.             this.destroyed = true;
  433.             this.ngroups = 0;
  434.             this.groups = null;
  435.             this.nthreads = 0;
  436.             this.threads = null;
  437.          }
  438.       } catch (Throwable var5) {
  439.          throw var5;
  440.       }
  441.  
  442.       for(int var3 = 0; var3 < var1; ++var3) {
  443.          var2[var3].destroy();
  444.       }
  445.  
  446.       if (this.parent != null) {
  447.          this.parent.remove(this);
  448.       }
  449.  
  450.    }
  451.  
  452.    private final void add(ThreadGroup var1) {
  453.       synchronized(this){}
  454.  
  455.       try {
  456.          if (this.destroyed) {
  457.             throw new IllegalThreadStateException();
  458.          }
  459.  
  460.          SecurityManager.enablePrivilege("UniversalThreadGroupAccess");
  461.          if (this.groups == null) {
  462.             this.groups = new ThreadGroup[4];
  463.          } else if (this.ngroups == this.groups.length) {
  464.             ThreadGroup[] var4 = new ThreadGroup[this.ngroups * 2];
  465.             System.arraycopy(this.groups, 0, var4, 0, this.ngroups);
  466.             this.groups = var4;
  467.          }
  468.  
  469.          this.groups[this.ngroups] = var1;
  470.          ++this.ngroups;
  471.       } catch (Throwable var6) {
  472.          throw var6;
  473.       }
  474.  
  475.    }
  476.  
  477.    private void remove(ThreadGroup var1) {
  478.       synchronized(this){}
  479.  
  480.       try {
  481.          if (!this.destroyed) {
  482.             for(int var4 = 0; var4 < this.ngroups; ++var4) {
  483.                if (this.groups[var4] == var1) {
  484.                   --this.ngroups;
  485.                   System.arraycopy(this.groups, var4 + 1, this.groups, var4, this.ngroups - var4);
  486.                   this.groups[this.ngroups] = null;
  487.                   break;
  488.                }
  489.             }
  490.  
  491.             if (this.nthreads == 0) {
  492.                this.notifyAll();
  493.             }
  494.  
  495.             if (this.daemon && this.nthreads == 0 && this.ngroups == 0) {
  496.                SecurityManager.enablePrivilege("UniversalThreadGroupAccess");
  497.                this.destroy();
  498.             }
  499.  
  500.             return;
  501.          }
  502.       } catch (Throwable var6) {
  503.          throw var6;
  504.       }
  505.  
  506.    }
  507.  
  508.    void add(Thread var1) {
  509.       synchronized(this){}
  510.  
  511.       try {
  512.          if (this.destroyed) {
  513.             throw new IllegalThreadStateException();
  514.          }
  515.  
  516.          if (this.threads == null) {
  517.             this.threads = new Thread[4];
  518.          } else if (this.nthreads == this.threads.length) {
  519.             Thread[] var4 = new Thread[this.nthreads * 2];
  520.             System.arraycopy(this.threads, 0, var4, 0, this.nthreads);
  521.             this.threads = var4;
  522.          }
  523.  
  524.          this.threads[this.nthreads] = var1;
  525.          ++this.nthreads;
  526.       } catch (Throwable var6) {
  527.          throw var6;
  528.       }
  529.  
  530.    }
  531.  
  532.    void remove(Thread var1) {
  533.       synchronized(this){}
  534.  
  535.       try {
  536.          if (!this.destroyed) {
  537.             for(int var4 = 0; var4 < this.nthreads; ++var4) {
  538.                if (this.threads[var4] == var1) {
  539.                   System.arraycopy(this.threads, var4 + 1, this.threads, var4, --this.nthreads - var4);
  540.                   this.threads[this.nthreads] = null;
  541.                   break;
  542.                }
  543.             }
  544.  
  545.             if (this.nthreads == 0) {
  546.                this.notifyAll();
  547.             }
  548.  
  549.             if (this.daemon && this.nthreads == 0 && this.ngroups == 0) {
  550.                this.destroy();
  551.             }
  552.  
  553.             return;
  554.          }
  555.       } catch (Throwable var6) {
  556.          throw var6;
  557.       }
  558.  
  559.    }
  560.  
  561.    public void list() {
  562.       this.list(System.out, 0);
  563.    }
  564.  
  565.    void list(PrintStream var1, int var2) {
  566.       synchronized(this){}
  567.  
  568.       int var3;
  569.       ThreadGroup[] var4;
  570.       try {
  571.          for(int var7 = 0; var7 < var2; ++var7) {
  572.             var1.print(" ");
  573.          }
  574.  
  575.          var1.println(this);
  576.          var2 += 4;
  577.  
  578.          for(int var8 = 0; var8 < this.nthreads; ++var8) {
  579.             for(int var9 = 0; var9 < var2; ++var9) {
  580.                var1.print(" ");
  581.             }
  582.  
  583.             var1.println(this.threads[var8]);
  584.          }
  585.  
  586.          var3 = this.ngroups;
  587.          if (this.groups != null) {
  588.             var4 = new ThreadGroup[var3];
  589.             System.arraycopy(this.groups, 0, var4, 0, var3);
  590.          } else {
  591.             var4 = null;
  592.          }
  593.       } catch (Throwable var11) {
  594.          throw var11;
  595.       }
  596.  
  597.       for(int var5 = 0; var5 < var3; ++var5) {
  598.          var4[var5].list(var1, var2);
  599.       }
  600.  
  601.    }
  602.  
  603.    public void uncaughtException(Thread var1, Throwable var2) {
  604.       if (this.parent != null) {
  605.          this.parent.uncaughtException(var1, var2);
  606.       } else {
  607.          if (!(var2 instanceof ThreadDeath)) {
  608.             var2.printStackTrace(System.err);
  609.          }
  610.  
  611.       }
  612.    }
  613.  
  614.    public boolean allowThreadSuspension(boolean var1) {
  615.       this.vmAllowSuspension = var1;
  616.       return true;
  617.    }
  618.  
  619.    public String toString() {
  620.       return this.getClass().getName() + "[name=" + this.getName() + ",maxpri=" + this.maxPriority + "]";
  621.    }
  622.  
  623.    private ThreadGroup enumeratableThreadGroup() {
  624.       ThreadGroup var1 = Thread.currentThread().getThreadGroup();
  625.       if (var1 != this && !var1.parentOf(this)) {
  626.          return this.parentOf(var1) ? var1 : null;
  627.       } else {
  628.          return this;
  629.       }
  630.    }
  631. }
  632.